In [6]:

    

class Simple:
    
    def __str__(self):
        return 'Simple {id}'.format(id=id(self))

simple_instance = Simple()
simple_instance_two = Simple()

print(simple_instance)
print(simple_instance_two)


    

    




Simple 4386680168
Simple 4387615296

In [11]:

    

class Dog:
    """
    A class that represents a Dog and the sound a dog can make
    """
    
    def __init__(self):
        self.sound = 'bark'
        self.category = 'mammal'
    
    def speak(self):
        """Returns the sound a dog makes"""
        return self.sound
    

my_dog = Dog()
print('A dog goes', my_dog.speak())
print('A dog is a', my_dog.category)


    

    




A dog goes bark
A dog is a mammal

In [16]:

    

class Room:
    
    def __init__(self, size, name):
        self.size = size
        self.name = name
        
    def get_name(self):
        name_list = self.name.split('_')
        name_list_normalized = [word.capitalize() for word in name_list]
        return ' '.join(name_list_normalized)
    
    def __str__(self):
        return '{name} ({size})'.format(
            name=self.get_name(),
            size=self.size
        )

one_room = Room(100, 'play_room')
print(one_room)
print([one_room])

list_of_rooms = [one_room]
for room in list_of_rooms:
    print(room)


    

    




Play Room (100)
[<__main__.Room object at 0x10585bc88>]
Play Room (100)

In [17]:

    

## Relationship to dictionaries
from pprint import pprint
rooms_with_size = {
    'kitchen': 400,
    'living_room': 200,
    'dining_room': 250,
    'bedroom_one': 400,
    'bedroom_two': 300,
    'master_bedroom': 350,
    'bedroom_three': 200,
    'basement': 800,
    'attic': 475
}

pprint(rooms_with_size)

class Room:
    
    def __init__(self, size, name):
        self.size = size
        self.name = name
        
    def get_name(self):
        name_list = self.name.split('_')
        name_list_normalized = [word.capitalize() for word in name_list]
        return ' '.join(name_list_normalized)
    
    def __str__(self):
        return '{name} ({size})'.format(
            name=self.get_name(),
            size=self.size
        )

rooms = [
    Room(size, room_name) 
    for (room_name, size) in rooms_with_size.items()
]

for room in rooms:
    print()
    print(room)


    

    




{'attic': 475,
 'basement': 800,
 'bedroom_one': 400,
 'bedroom_three': 200,
 'bedroom_two': 300,
 'dining_room': 250,
 'kitchen': 400,
 'living_room': 200,
 'master_bedroom': 350}

Kitchen (400)

Attic (475)

Bedroom Two (300)

Dining Room (250)

Master Bedroom (350)

Bedroom Three (200)

Living Room (200)

Bedroom One (400)

Basement (800)

In [22]:

    

class Person:
    
    def __init__(self, age, name, rooms=None):
        self.age = age
        self.name = name
        

        if rooms is None:
            self.rooms = []
        else:
            self.rooms = rooms
    
    def add_room(self, room):
        self.rooms.append(room)
    
    def remove_room(self, room):
        self.rooms.remove(room)
        
    def __str__(self):
        return '{name} {ll}'.format(
            name=self.name,
            ll=self.rooms
            )
        
kid_one = Person(10, 'Bill')
kid_two = Person(8, 'Sandy')
adult_one = Person(34, 'Sam')
adult_two = Person(28, 'Chris')

print(kid_one, kid_two, adult_one, adult_two)


    

    




Bill [] Sandy [] Sam [] Chris []

In [23]:

    

rooms_with_size = {
    'kitchen': 400,
    'living_room': 200,
    'dining_room': 250,
    'bedroom_one': 400,
    'bedroom_two': 300,
    'master_bedroom': 350,
    'bedroom_three': 200,
    'basement': 800,
    'attic': 475
}

class Room:
    
    def __init__(self, size, name):
        self.size = size
        self.name = name
        
    def get_name(self):
        name_list = self.name.split('_')
        name_list_normalized = [word.capitalize() for word in name_list]
        return ' '.join(name_list_normalized)
    
    def __str__(self):
        return '{name} ({size})'.format(
            name=self.get_name(),
            size=self.size
        )

    
class Person:
    
    def __init__(self, age, name, rooms=None):
        self.age = age
        self.name = name
        
        if rooms is None:
            self.rooms = []
        else:
            self.rooms = rooms
    
    def add_room(self, room):
        self.rooms.append(room)
    
    def remove_room(self, room):
        self.rooms.remove(room)
        
    def __str__(self):
        return str((self.name, self.age))

    
rooms = [
    Room(size, room_name) 
    for (room_name, size) in rooms_with_size.items()
]

chip = Person(45, 'Chip', rooms)

print(chip)
print('Name:', chip.name)
print('Age:', chip.age)
print('Rooms:', chip.rooms)

print()
for room in chip.rooms:
    print(room)


    

    




('Chip', 45)
Name: Chip
Age: 45
Rooms: [<__main__.Room object at 0x105776748>, <__main__.Room object at 0x1058900f0>, <__main__.Room object at 0x1058900b8>, <__main__.Room object at 0x105890128>, <__main__.Room object at 0x105890160>, <__main__.Room object at 0x105890198>, <__main__.Room object at 0x1058901d0>, <__main__.Room object at 0x105890208>, <__main__.Room object at 0x105890240>]

Kitchen (400)
Attic (475)
Bedroom Two (300)
Dining Room (250)
Master Bedroom (350)
Bedroom Three (200)
Living Room (200)
Bedroom One (400)
Basement (800)

In [24]:

    

rooms_with_size = {
    'kitchen': 400,
    'living_room': 200,
    'dining_room': 250,
    'bedroom_one': 400,
    'bedroom_two': 300,
    'master_bedroom': 350,
    'bedroom_three': 200,
    'basement': 800,
    'attic': 475
}

class Room:
    
    def __init__(self, size, name):
        self.size = size
        self.name = name
        
    def get_name(self):
        name_list = self.name.split('_')
        name_list_normalized = [word.capitalize() for word in name_list]
        return ' '.join(name_list_normalized)
    
    def __str__(self):
        return '{name} ({size})'.format(
            name=self.get_name(),
            size=self.size
        )

    
class Person:
    
    def __init__(self, age, name, rooms=None):
        self.age = age
        self.name = name
        
        if rooms is None:
            self.rooms = []
        else:
            self.rooms = rooms
    
    def add_room(self, room):
        self.rooms.append(room)
    
    def remove_room(self, room):
        self.rooms.remove(room)
    
    def print_rooms(self):
        for room in self.rooms:
            print(room)
        
    def __str__(self):
        return str((self.name, self.age))

jennifer = Person(67, 'Jennifer')
    
for room_name, size in rooms_with_size.items():
    new_room = Room(size, room_name)
    jennifer.add_room(new_room)
    
jennifer.print_rooms()


    

    




Kitchen (400)
Attic (475)
Bedroom Two (300)
Dining Room (250)
Master Bedroom (350)
Bedroom Three (200)
Living Room (200)
Bedroom One (400)
Basement (800)

In [27]:

    

from random import choice 

class Person:
    
    def __init__(self, age, name, rooms=None):
        self.age = age
        self.name = name
        
        if rooms is None:
            self.rooms = []
        else:
            self.rooms = rooms
    
    def __str__(self):
        return self.name
    
    def add_room(self, room):
        self.rooms.append(room)
    
    def remove_room(self, room):
        self.rooms.remove(room)
        
    def amount_cleaned(self):
        amount = 0
        
        for room in self.rooms:
            amount += room.size
        
        return amount
    
    def print_rooms(self):
        for room in self.rooms:
            print(room)

            
rooms_with_size = {
    'kitchen': 400,
    'living_room': 200,
    'dining_room': 250,
    'bedroom_one': 400,
    'bedroom_two': 300,
    'master_bedroom': 350,
    'bedroom_three': 200,
    'basement': 800,
    'attic': 475
}


class Room:
    
    def __init__(self, size, name):
        self.size = size
        self.name = name
        
    def get_name(self):
        name_list = self.name.split('_')
        name_list_normalized = [word.capitalize() for word in name_list]
        return ' '.join(name_list_normalized)
    
    def __str__(self):
        return '{name} ({size})'.format(
            name=self.get_name(),
            size=self.size
        )

        
kid_one = Person(10, 'Bill')
kid_two = Person(8, 'Sandy')
adult_one = Person(34, 'Sam')
adult_two = Person(28, 'Chris')

people = [kid_one, kid_two, adult_one, adult_two]

rooms = [
    Room(size, room_name) 
    for (room_name, size) in rooms_with_size.items()
]


## Setup rooms
rooms_to_clean = rooms.copy()

while len(rooms_to_clean) > 0:
    
    # Randomly assign a person to a chore
    person = choice(people) 
    room = choice(rooms_to_clean)
    
    person.add_room(room)
    
    # This ensures we stop our loop at some point
    rooms_to_clean.remove(room)

    
for person in people:
    print(person, 'cleaned a total of', person.amount_cleaned(), 'square feet')
    person.print_rooms()
    
    print()


    

    




Bill cleaned a total of 850 square feet
Bedroom Two (300)
Bedroom Three (200)
Master Bedroom (350)

Sandy cleaned a total of 1725 square feet
Bedroom One (400)
Attic (475)
Kitchen (400)
Living Room (200)
Dining Room (250)

Sam cleaned a total of 800 square feet
Basement (800)

Chris cleaned a total of 0 square feet

In [29]:

    

from random import choice 

class Person:
    
    def __init__(self, age, name, rooms=None):
        self.age = age
        self.name = name
        
        if rooms is None:
            self.rooms = []
        else:
            self.rooms = rooms
    
    def __str__(self):
        return self.name
    
    def add_room(self, room):
        self.rooms.append(room)
    
    def remove_room(self, room):
        self.rooms.remove(room)
        
    def amount_cleaned(self):
        amount = 0
        
        for room in self.rooms:
            amount += room.size
        
        return amount
    
    def average_amount_cleaned(self):  
        number_of_rooms = len(self.rooms)
        
        if number_of_rooms > 0:
            return round(self.amount_cleaned() / number_of_rooms, 2)
        
        return 0.0
    
    def print_rooms(self):
        for room in self.rooms:
            print(room)

            
rooms_with_size = {
    'kitchen': 400,
    'living_room': 200,
    'dining_room': 250,
    'bedroom_one': 400,
    'bedroom_two': 300,
    'master_bedroom': 350,
    'bedroom_three': 200,
    'basement': 800,
    'attic': 475
}


class Room:
    
    def __init__(self, size, name):
        self.size = size
        self.name = name
        
    def get_name(self):
        name_list = self.name.split('_')
        name_list_normalized = [word.capitalize() for word in name_list]
        return ' '.join(name_list_normalized)
    
    def __str__(self):
        return '{name} ({size})'.format(
            name=self.get_name(),
            size=self.size
        )

        
kid_one = Person(10, 'Bill')
kid_two = Person(8, 'Sandy')
adult_one = Person(34, 'Sam')
adult_two = Person(28, 'Chris')

people = [kid_one, kid_two, adult_one, adult_two]

rooms = [
    Room(size, room_name) 
    for (room_name, size) in rooms_with_size.items()
]

## Setup rooms
rooms_to_clean = rooms.copy()

while len(rooms_to_clean) > 0:
    
    # Randomly assign a person to a chore
    person = choice(people) 
    room = choice(rooms_to_clean)
    
    person.add_room(room)
    
    # This ensures we stop our loop at some point
    rooms_to_clean.remove(room)

    
for person in people:
    print(person, 'cleaned a total of', person.amount_cleaned(), 'square feet')
    print(person, 'cleaned an average of', person.average_amount_cleaned(), 'square feet per room')
    person.print_rooms()
    
    print()


    

    




Bill cleaned a total of 1000 square feet
Bill cleaned an average of 333.33 square feet per room
Kitchen (400)
Master Bedroom (350)
Dining Room (250)

Sandy cleaned a total of 1100 square feet
Sandy cleaned an average of 550.0 square feet per room
Bedroom Two (300)
Basement (800)

Sam cleaned a total of 1075 square feet
Sam cleaned an average of 358.33 square feet per room
Bedroom Three (200)
Bedroom One (400)
Attic (475)

Chris cleaned a total of 200 square feet
Chris cleaned an average of 200.0 square feet per room
Living Room (200)

In [ ]: